from typing import Dict, Any, List
from .base_agent import BaseAgent, AgentResult
from datetime import datetime
from .llm_client import get_llm_client
import logging

# 配置日志
logger = logging.getLogger(__name__)

class CopywritingGenerationAgent(BaseAgent):
    """重构的文案生成智能体"""
    
    def __init__(self, config_path: str = None):
        super().__init__()
        self.config_path = config_path
        self.name = "CopywritingGenerationAgent"
        self.version = "2.0.0"  # 更新版本号
        # 初始化LLM客户端
        self.llm_client = get_llm_client()
    
    def get_name(self) -> str:
        return self.name
    
    def get_version(self) -> str:
        return self.version
    
    def get_dependencies(self) -> List[str]:
        return ["DataCollectionAgent", "SummaryGenerationAgent"]
    
    # 添加一个简单的LRU缓存
    _generation_cache = {}
    _cache_max_size = 100  # 增加缓存容量以提高命中率
    # 核心平台列表：仅支持三个主要平台
    _supported_platforms = ['weibo', 'douyin', 'wechat']
    
    def _get_cache_key(self, title, content, platform, styles=None):
        """生成缓存键"""
        styles_str = "_styles_" + ",".join(sorted(styles)) if styles else ""
        return f"{title[:50]}_{content[:100]}_{platform}{styles_str}"
    
    def _update_cache(self, key, value):
        """更新缓存并控制大小"""
        if key in self._generation_cache:
            # 如果已存在，先删除再添加到末尾
            del self._generation_cache[key]
        
        # 添加新值到缓存末尾
        self._generation_cache[key] = value
        
        # 如果缓存超过最大大小，删除最早的项
        if len(self._generation_cache) > self._cache_max_size:
            oldest_key = next(iter(self._generation_cache.keys()))
            del self._generation_cache[oldest_key]
    
    def execute(self, input_data: Dict[str, Any]) -> AgentResult:
        self.log_execution_start()
        start_time = datetime.now()
        
        try:
            # 从输入中获取必要数据
            hotspot_title = input_data.get("hotspot_title")
            hotspot_content = input_data.get("hotspot_content")
            platforms = input_data.get("platforms", {})
            styles = input_data.get("styles", [])
            
            # 从SummaryGenerationAgent的结果中获取真实的热点内容
            summary_data = input_data.get("SummaryGenerationAgent_result", {})
            real_hotspot_content = self._extract_hotspot_content(summary_data, hotspot_title)
            
            # 验证必要参数
            if not hotspot_title:
                execution_time = (datetime.now() - start_time).total_seconds()
                self.log_execution_end(False, execution_time)
                return AgentResult(
                    success=False,
                    data={},
                    error="缺少热点标题"
                )
            
            # 准备使用LLM生成文案的基础数据
            content_to_use = real_hotspot_content or hotspot_content or "暂无详细内容"
            
            # 标准化平台名称
            normalized_platforms = self._normalize_platforms(platforms)
            
            # 检查LLM服务可用性 (优化: 避免不必要的简单调用测试)
            llm_available = False
            try:
                if self.llm_client:
                    # 优先使用is_available方法
                    if hasattr(self.llm_client, 'is_available'):
                        llm_available = self.llm_client.is_available()
                    else:
                        # 避免通过生成文本测试可用性，直接检查client对象
                        client = getattr(self.llm_client, 'client', None)
                        llm_available = client is not None
                
                if llm_available:
                    logger.info("LLM服务可用，将使用LLM生成高质量文案")
                else:
                    logger.warning("LLM服务暂时不可用，将使用优化的回退机制生成文案")
            except Exception as llm_check_error:
                logger.warning(f"LLM服务可用性检查失败: {str(llm_check_error)}")
                llm_available = False
            
            # 为每个平台生成高质量文案
            result = {}
            # 获取用户实际选择的平台列表（仅包含支持的3个平台）
            selected_platforms = [p for p in self._supported_platforms 
                                if normalized_platforms.get(p, True)]
            logger.info(f"准备为以下平台生成文案: {selected_platforms}")
            
            # 优化：对于LLM可用的情况，尝试并行生成文案
            if llm_available and len(selected_platforms) > 1 and hasattr(self.llm_client, 'generate_text_parallel'):
                logger.info(f"使用并行生成模式处理{len(selected_platforms)}个平台")
                
                # 准备并行生成所需的数据
                platform_prompts = []
                platform_cache_keys = []
                platforms_to_process = []
                
                # 先检查缓存，只对缓存未命中的平台进行并行处理
                for platform in selected_platforms:
                    cache_key = self._get_cache_key(hotspot_title, content_to_use, platform, styles)
                    if cache_key in self._generation_cache:
                        logger.info(f"从缓存获取{platform}平台文案")
                        cached_content = self._generation_cache[cache_key].copy()
                        cached_content['generation_method'] = 'cached_llm'
                        result[platform] = cached_content
                    else:
                        # 为缓存未命中的平台准备数据（优化：调整token数量以提高响应速度）
                        platform_max_tokens = {
                            'weibo': 400,
                            'douyin': 1200,
                            'wechat': 1800
                        }
                        prompt = self._get_platform_prompt(platform, hotspot_title, content_to_use, styles)
                        platform_prompts.append((prompt, platform_max_tokens.get(platform, 1500), 0.3))
                        platform_cache_keys.append(cache_key)
                        platforms_to_process.append(platform)
                
                # 如果有需要并行处理的平台
                if platform_prompts:
                    # 记录并行处理开始时间
                    parallel_start_time = datetime.now()
                    # 执行并行生成（优化：增加线程池大小，但不超过平台数量）
                    max_workers = min(3, len(platform_prompts))
                    logger.info(f"启动并行处理，线程数: {max_workers}")
                    parallel_results = self.llm_client.generate_text_parallel(platform_prompts, max_workers=max_workers)
                    # 记录并行处理时间
                    parallel_time = (datetime.now() - parallel_start_time).total_seconds()
                    logger.info(f"并行处理完成，耗时: {parallel_time:.2f}秒")
                    
                    # 处理并行生成的结果
                    for i, platform in enumerate(platforms_to_process):
                        try:
                            llm_result = parallel_results[i]
                            # 解析LLM输出并添加额外信息
                            platform_content = self._parse_llm_response(platform, llm_result)
                            platform_content['suggestions'] = self._get_platform_suggestions(platform)
                            platform_content['editable'] = True
                            platform_content['generation_method'] = 'parallel_llm'
                            platform_content['llm_status'] = 'available'
                            
                            # 风格变体生成功能已被移除，提高执行效率
                            
                            result[platform] = platform_content
                            # 更新缓存
                            self._update_cache(platform_cache_keys[i], platform_content.copy())
                        except Exception as e:
                            logger.error(f"处理{platform}平台并行结果失败: {str(e)}")
                            # 出错时回退到单平台处理
                            fallback_content = self._generate_fallback_content(platform, hotspot_title, content_to_use)
                            fallback_content['error'] = str(e)
                            fallback_content['generation_method'] = 'error_fallback'
                            fallback_content['llm_status'] = 'error'
                            result[platform] = fallback_content
            else:
                # 单平台串行处理模式（回退或单平台情况）
                for platform in selected_platforms:
                    # 确保平台存在于结果字典中
                    if platform not in result:
                        result[platform] = {}
                    
                    try:
                        # 尝试从缓存获取
                        cache_key = self._get_cache_key(hotspot_title, content_to_use, platform, styles)
                        if cache_key in self._generation_cache:
                            logger.info(f"从缓存获取{platform}平台文案")
                            cached_content = self._generation_cache[cache_key].copy()
                            # 更新生成方法标识但保留缓存内容
                            cached_content['generation_method'] = 'cached_llm' if llm_available else 'cached_fallback'
                            result[platform] = cached_content
                            continue
                        
                        if llm_available:
                            # 使用LLM为每个平台生成专业文案
                            platform_content = self._generate_platform_content(
                                platform=platform,
                                title=hotspot_title,
                                content=content_to_use,
                                styles=styles
                            )
                            platform_content['generation_method'] = 'llm'
                            platform_content['llm_status'] = 'available'
                            result[platform] = platform_content
                        else:
                            # 使用优化的回退机制
                            fallback_content = self._generate_fallback_content(platform, hotspot_title, content_to_use)
                            fallback_content['generation_method'] = 'optimized_fallback'
                            fallback_content['llm_status'] = 'unavailable'
                            result[platform] = fallback_content
                        
                        # 将生成的内容加入缓存
                        self._update_cache(cache_key, result[platform].copy())
                        
                    except Exception as e:
                        logger.error(f"生成{platform}平台文案失败: {str(e)}")
                        # 出错时使用回退方案
                        error_fallback = self._generate_fallback_content(platform, hotspot_title, content_to_use)
                        error_fallback['error'] = str(e)
                        error_fallback['generation_method'] = 'error_fallback'
                        error_fallback['llm_status'] = 'error'
                        result[platform] = error_fallback
            
            execution_time = (datetime.now() - start_time).total_seconds()
            logger.info(f"文案生成总耗时: {execution_time:.2f}秒，平台数量: {len(selected_platforms)}")
            self.log_execution_end(True, execution_time)
            
            # 处理platforms类型，避免调用不存在的方法
            platforms_list = []
            if isinstance(platforms, dict):
                platforms_list = [p for p in list(platforms.keys()) if p in self._supported_platforms]
            elif isinstance(platforms, list):
                platforms_list = [p for p in platforms if p in self._supported_platforms]
                
            return AgentResult(
                success=True,
                data=result,
                metadata={
                    "platforms": platforms_list,
                    "styles": styles[:3],  # 限制风格数量
                    "execution_time": execution_time,
                    "timestamp": datetime.now().isoformat(),
                    "llm_available": llm_available,
                    "model_version": self.version
                }
            )
            
        except Exception as e:
            logger.error(f"文案生成主流程失败: {str(e)}")
            import traceback
            logger.debug(f"详细错误信息: {traceback.format_exc()}")
            execution_time = (datetime.now() - start_time).total_seconds()
            self.log_execution_end(False, execution_time)
            return AgentResult(
                success=False,
                data={},
                error=f"文案生成失败: {str(e)}",
                metadata={
                    "execution_time": execution_time,
                    "timestamp": datetime.now().isoformat(),
                    "error_code": "EXECUTION_ERROR"
                }
            )

    
    def _normalize_platforms(self, platforms):
        """标准化平台名称"""
        platform_mapping = {
            '微博': 'weibo',
            'weibo': 'weibo',
            '抖音': 'douyin',
            'douyin': 'douyin',
            '头条': 'toutiao',
            'toutiao': 'toutiao',
            '微信': 'wechat',
            'wechat': 'wechat'
        }
        
        normalized = {}
        
        if isinstance(platforms, dict):
            # 对于布尔值平台对象
            for plat_name, is_enabled in platforms.items():
                if is_enabled:
                    normalized_name = plat_name.lower()
                    if normalized_name in platform_mapping:
                        normalized[platform_mapping[normalized_name]] = True
        elif isinstance(platforms, list):
            # 对于平台名称列表
            for platform_name in platforms:
                normalized_name = platform_name.lower()
                if normalized_name in platform_mapping:
                    normalized[platform_mapping[normalized_name]] = True
        
        return normalized
    
    def _generate_platform_content(self, platform, title, content, styles):
        """使用LLM为特定平台生成高质量内容"""
        # 根据平台获取专业提示词
        prompt = self._get_platform_prompt(platform, title, content, styles)
        
        # 调用LLM生成内容
        try:
            # 优化LLM调用参数：根据平台调整max_tokens（优化：减少token数量）
            platform_max_tokens = {
                'weibo': 400,  # 减少tokens，提高响应速度
                'douyin': 1200,  # 减少tokens，提高响应速度
                'wechat': 1800  # 减少tokens，提高响应速度
            }
            
            llm_result = self.llm_client.generate_text(
                prompt=prompt,
                max_tokens=platform_max_tokens.get(platform, 1500),  # 优化token数量
                temperature=0.3  # 保持温度不变以确保内容质量
            )
            
            # 解析LLM输出
            platform_content = self._parse_llm_response(platform, llm_result)
            
            # 添加平台特定的建议
            platform_content['suggestions'] = self._get_platform_suggestions(platform)
            platform_content['editable'] = True
            
            # 风格变体生成功能已被移除，提高执行效率
            
            return platform_content
        except Exception as e:
            logger.error(f"LLM调用失败: {str(e)}")
            raise
    
    def _get_platform_prompt(self, platform, title, content, styles):
        """根据平台获取提示词模板（精简版本，提高效率）"""
        
        # 进一步缩短内容长度，减少token消耗
        content_short = content[:200] + "..." if len(content) > 200 else content
        
        # 各平台专用提示词模板（极简化版本）
        if platform == 'weibo':
            return f"创作微博文案：\n标题：{title}\n内容：{content_short}\n要求：100字内，加1-2个话题标签，简洁有力。直接输出。"
        elif platform == 'douyin':
            return f"创作抖音文案：\n标题：{title}\n内容：{content_short}\n要求：吸引人的开头，口语化表达。直接输出。"
        elif platform == 'wechat':
            return f"创作微信文章：\n标题：{title}\n内容：{content_short}\n要求：结构清晰，情感化表达。直接输出。"
        else:
            return f"创作文章：\n标题：{title}\n内容：{content_short}\n要求：内容清晰，信息准确。直接输出。"
    
    def _parse_llm_response(self, platform, llm_result):
        """解析LLM返回的响应（优化版本，仅支持三个核心平台）"""
        # 清理返回结果
        content = llm_result.strip()
        
        result = {
            'content': content,
            'title': '',
            'editable': True
        }
        
        # 提取标题（所有平台通用的简单规则）
        lines = content.split('\n')
        for line in lines:
            if line.strip():
                result['title'] = line.strip()[:50]  # 标题最多50字
                break
        
        # 如果没有找到合适的标题，就用内容的前30个字作为标题
        if not result['title']:
            result['title'] = content[:30] + '...' if len(content) > 30 else content
        
        # 提取内容（去掉标题部分）
        if result['title'] and lines:
            content_lines = lines[1:] if lines[0].strip().startswith(result['title']) else lines
            result['content'] = '\n'.join([line for line in content_lines if line.strip()])
        
        # 平台特定处理
        if platform == 'weibo':
            # 保留原始内容，不要移除标题
            result['content'] = content
            
            # 从微博文案中提取话题标签
            import re
            hashtags = re.findall(r'#([^#]+)#', content)
            if hashtags:
                result['hashtags'] = [f"#{tag}#" for tag in hashtags[:4]]
            else:
                # 生成默认标签
                result['hashtags'] = [f"#{item}#" for item in ["热点速看", "实时关注", "观点热议"]]
        elif platform == 'douyin':
            # 抖音可能有分镜脚本标记，如果有就提取
            if '分镜脚本:' in content or '脚本:' in content:
                parts = content.split('分镜脚本:') if '分镜脚本:' in content else content.split('脚本:')
                result['content'] = parts[0].replace('文案:', '').strip() if len(parts) > 0 else content
                result['video_script'] = parts[1].strip() if len(parts) > 1 else "[开场] 3秒强视觉冲击+大字幕\n[钩子] 0~3秒：引人入胜的问题\n[高潮] 核心内容展示\n[结尾] 互动引导"
        elif platform == 'wechat':
            # 微信内容保持原样
            pass
        
        return result
    
    def _get_platform_suggestions(self, platform):
        """获取平台特定的发布建议"""
        suggestions = {
            'weibo': [
                "发布前可编辑修改文案，调整情绪表达强度",
                "配图：1-2张信息图或表情包，提升传播效果",
                "发布后及时回应评论，增加互动热度",
                "黄金发布时段：12-13点，19-22点"
            ],
            'douyin': [
                "选择与文案情绪匹配的热门BGM，增强感染力",
                "视频开头3秒必须有强烈视觉冲击",
                "控制视频时长在60秒以内，节奏紧凑",
                "使用醒目字幕和动态转场效果"
            ],
            'wechat': [
                "文章首屏添加摘要或要点图，提升第一印象",
                "文中插入3-5张高质量图片或信息图表",
                "每段文字控制在3行以内，提高阅读体验",
                "文末设计引导关注和评论的互动环节"
            ]
        }
        
        return suggestions.get(platform, ["根据平台特性调整发布策略"])
    
    # 风格变体生成功能已被移除，提高执行效率
    
    def _generate_fallback_content(self, platform, title, content):
        """当LLM不可用时的回退方案，生成高质量的平台特定文案"""
        # 提取内容中的关键词，用于生成更相关的标签和内容
        keywords = self._extract_keywords(title, content)
        
        # 为不同平台生成高质量的回退文案模板
        fallback_templates = {
            'weibo': {
                'content': self._generate_high_quality_weibo(title, content, keywords),
                'hashtags': self._generate_relevant_hashtags(title, keywords)
            },
            'douyin': {
                'content': self._generate_high_quality_douyin(title, content, keywords),
                'video_script': self._generate_douyin_script(title, content)
            },
            'wechat': {
                'content': self._generate_high_quality_wechat(title, content, keywords)
            },
            'toutiao': {
                'content': self._generate_high_quality_toutiao(title, content, keywords)
            }
        }
        
        # 获取当前平台的回退内容
        platform_data = fallback_templates.get(platform, {})
        basic_content = {
            "content": platform_data.get('content', f"【{title}】\n{content[:150]}...\n\n[温馨提示：LLM服务暂时不可用，文案已使用优化回退模板生成]"),
            "suggestions": self._get_manual_optimization_suggestions(platform),
            "editable": True
        }
        
        # 添加平台特定内容
        if platform == 'weibo' and 'hashtags' in platform_data:
            basic_content['hashtags'] = platform_data['hashtags']
        elif platform == 'douyin' and 'video_script' in platform_data:
            basic_content['video_script'] = platform_data['video_script']
        
        return basic_content
    
    def _extract_keywords(self, title, content):
        """从标题和内容中提取关键词"""
        # 简单的关键词提取逻辑
        all_text = (title + ' ' + content).replace('，', ' ').replace('。', ' ')
        # 过滤掉常见的停用词
        stop_words = {'的', '了', '是', '在', '我', '有', '和', '就', '不', '人', '都', '一', '一个', '上', '也', '很', '到', '说', '要', '去', '你', '会', '着', '没有', '看', '好', '自己', '这'}
        words = [w for w in all_text.split() if w not in stop_words and len(w) > 1]
        # 返回前5个最常见的词作为关键词
        from collections import Counter
        return [word for word, _ in Counter(words).most_common(5)]
    
    def _generate_high_quality_weibo(self, title, content, keywords):
        """生成高质量的微博文案"""
        emotion_intros = [
            "震惊！", "没想到！", "注意了！", "重要提醒！", "刚刚！",
            "突发！", "热议中！", "重磅！", "最新消息！", "速看！"
        ]
        
        # 选择一个适合的情感开头
        import random
        intro = random.choice(emotion_intros)
        
        # 构建微博文案
        weibo_content = f"{intro}{title}\n\n{content[:80]}...\n\n这反映了什么？欢迎留言讨论！"
        
        # 添加相关话题标签提示
        if keywords:
            tags_str = ' '.join([f"#{kw}#" for kw in keywords[:3]])
            weibo_content += f"\n\n{tags_str} #热点热议#"
        else:
            weibo_content += "\n\n#热点速看# #实时关注#"
        
        return weibo_content[:140]  # 确保不超过微博字数限制
    
    def _generate_relevant_hashtags(self, title, keywords):
        """生成相关的话题标签"""
        # 基础标签
        base_tags = ["#热点速看#", "#实时关注#"]
        
        # 添加关键词相关标签
        keyword_tags = [f"#{kw}#" for kw in keywords[:2]]
        
        # 组合并去重
        all_tags = base_tags + keyword_tags
        return list(dict.fromkeys(all_tags))[:4]  # 最多4个标签
    
    def _generate_high_quality_douyin(self, title, content, keywords):
        """生成高质量的抖音文案"""
        hook_phrases = [
            "你绝对想象不到...", "这个消息太劲爆了！", "3秒告诉你...",
            "所有人注意了！", "刚刚发生的事，赶紧看！", "一定要看到最后！",
            "没想到会是这样...", "太令人意外了！", "震惊所有人！"
        ]
        
        import random
        hook = random.choice(hook_phrases)
        
        # 构建抖音文案
        douyin_content = f"{hook}\n\n{title}\n\n{content[:100]}...\n\n你们觉得呢？欢迎评论区告诉我！\n\n记得点赞、收藏、转发，支持一下！"
        
        return douyin_content
    
    def _generate_douyin_script(self, title, content):
        """生成抖音分镜脚本"""
        return """
[开场 0-3秒]: 大字幕展示"#重磅消息#"
[钩子 3-7秒]: 强烈视觉冲击+核心问题提出
[铺垫 7-15秒]: 背景介绍，为什么这个事重要
[高潮 15-40秒]: 详细讲解事件经过和关键点
[结尾 40-60秒]: 总结观点+互动引导+悬念设置
        """.strip()
    
    def _generate_high_quality_wechat(self, title, content, keywords):
        """生成高质量的微信公众号文章"""
        subtitle = "深度解析：" + title if len(title) < 20 else title
        
        # 生成微信文章HTML格式
        wechat_article = f"""
<h1 style="text-align: center; color: #333;">{title}</h1>
<h3 style="text-align: center; color: #666;">{subtitle}</h3>

<p style="text-indent: 2em; line-height: 1.8;">各位读者好，今天我们要讨论的话题是：{title}。这一事件近期引发了广泛关注，背后可能隐藏着更深层次的社会意义。</p>

<h4 style="color: #444; margin-top: 20px;">一、事件背景</h4>
<p style="text-indent: 2em; line-height: 1.8;">{content[:200]}...</p>

<h4 style="color: #444; margin-top: 20px;">二、关键分析</h4>
<p style="text-indent: 2em; line-height: 1.8;">从多个角度来看，这一事件反映了当前社会的多个层面问题。首先，它涉及到...</p>
<p style="text-indent: 2em; line-height: 1.8;">其次，我们也应该注意到...</p>

<h4 style="color: #444; margin-top: 20px;">三、未来展望</h4>
<p style="text-indent: 2em; line-height: 1.8;">面对这样的情况，我们应该如何应对？又会对未来产生什么影响？</p>

<p style="text-indent: 2em; line-height: 1.8; margin-top: 20px;">欢迎在评论区留下你的看法，一起探讨这个话题！</p>

<p style="text-align: center; color: #999; margin-top: 30px;">— END —</p>
"""
        
        return wechat_article
    
    def _generate_high_quality_toutiao(self, title, content, keywords):
        """生成高质量的今日头条文章"""
        # 生成导语（50字以内）
        lead = f"{title}引发社会各界广泛关注，究竟发生了什么？"[:50]
        
        # 构建今日头条文章
        toutiao_article = f"""
【{title}】

{lead}

近日，{title}的消息在网络上迅速传播，引发了大量讨论。据了解，该事件发生在...

事件梳理：
{content[:300]}...

事件进展：
目前，相关方面已经采取了一系列措施，包括...

专家观点：
有专家表示，这一事件反映了当前社会的多个层面问题，值得我们深入思考。

对此，你有什么看法？欢迎在评论区留言讨论！
"""
        
        return toutiao_article
    
    def _get_manual_optimization_suggestions(self, platform):
        """获取手动优化建议"""
        platform_suggestions = {
            'weibo': [
                "请检查并优化情感表达强度，使其更具感染力",
                "确保话题标签与内容高度相关，提高曝光率",
                "建议添加1-2张高质量配图，增强传播效果",
                "发布时间建议选择在12-13点或19-22点"
            ],
            'douyin': [
                "建议添加与文案情绪匹配的热门BGM",
                "视频开头3秒至关重要，请确保有强烈视觉冲击",
                "可考虑添加字幕和动态转场效果",
                "互动引导语可根据目标受众调整"
            ],
            'wechat': [
                "建议添加3-5张高质量图片或信息图表",
                "每段文字控制在3行以内，提高阅读体验",
                "可在文末设计引导关注和评论的互动环节",
                "标题可考虑使用更具吸引力的表达"
            ],
            'toutiao': [
                "建议添加相关领域专家观点，提升权威性",
                "可使用数据和案例增强说服力",
                "设置2-3个小标题，增强内容可读性",
                "调整文章长度在800-1200字，信息密度适中"
            ]
        }
        
        base_suggestion = "LLM服务暂时不可用，文案已使用优化回退模板生成"
        platform_specific = platform_suggestions.get(platform, [])
        
        return [base_suggestion] + platform_specific
    
    def _extract_hotspot_content(self, summary_data: Dict[str, Any], target_title: str) -> str:
        """从SummaryGenerationAgent的结果中提取对应标题的热点内容"""
        if not summary_data or not target_title:
            return ""
        
        # 遍历所有平台的数据
        for platform_key, platform_data in summary_data.items():
            if not isinstance(platform_data, dict) or "data" not in platform_data:
                continue
                
            data_items = platform_data["data"]
            if not isinstance(data_items, list):
                continue
            
            # 查找匹配标题的热点事件
            for item in data_items:
                if not isinstance(item, dict):
                    continue
                    
                item_title = item.get("title", "")
                item_summary = item.get("summary", "")
                
                # 检查标题是否匹配（支持部分匹配）
                if (item_title and target_title and 
                    (item_title in target_title or target_title in item_title)):
                    return item_summary
                
                # 如果标题完全匹配，直接返回
                if item_title == target_title:
                    return item_summary
        
        # 如果没有找到完全匹配的，返回第一个可用的摘要
        for platform_key, platform_data in summary_data.items():
            if not isinstance(platform_data, dict) or "data" not in platform_data:
                continue
                
            data_items = platform_data["data"]
            if not isinstance(data_items, list) or not data_items:
                continue
            
            first_item = data_items[0]
            if isinstance(first_item, dict) and "summary" in first_item:
                return first_item["summary"]
        
        return ""
